home *** CD-ROM | disk | FTP | other *** search
/ ftp.mactech.com 2010 / ftp.mactech.com.tar / ftp.mactech.com / thinkref / archive / THINKPascalUH2.1.sea / THINKPas Univ Hdr 2.1 / Interfaces / Menus.p < prev    next >
Text File  |  1995-09-12  |  11KB  |  408 lines
  1. { Converted with MPW2TPas Tuesday, September 12, 1995 7:39:31 PM }
  2. {
  3.      File:        Menus.p
  4.  
  5.      Contains:    Menu Manager Interfaces.
  6.  
  7.      Version:    Technology:    System 7.5
  8.                  Package:    Universal Interfaces 2.1 in “MPW Latest” on ETO #18
  9.  
  10.      Copyright:    © 1984-1995 by Apple Computer, Inc.
  11.                  All rights reserved.
  12.  
  13.      Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  14.                  stack.  Include the file and version information (from above)
  15.                  in the problem description and send to:
  16.                      Internet:    apple.bugs@applelink.apple.com
  17.                      AppleLink:    APPLE.BUGS
  18.  
  19. }
  20.  
  21.  UNIT Menus;
  22.  INTERFACE
  23.  
  24.  
  25. {$IFC UNDEFINED __MENUS__}
  26. {$SETC __MENUS__ := 1}
  27.  
  28.   USES
  29.    ConditionalMacros, Types, Memory, Quickdraw;
  30.  
  31. { $PUSH}
  32. { $ALIGN MAC68K}
  33. { $LibExport+}
  34.  
  35. CONST
  36.     noMark                        = 0;                            {mark symbol for MarkItem}
  37. { menu defProc messages }
  38.     mDrawMsg                    = 0;
  39.     mChooseMsg                    = 1;
  40.     mSizeMsg                    = 2;
  41.     mDrawItemMsg                = 4;
  42.     mCalcItemMsg                = 5;
  43.     textMenuProc                = 0;
  44.     hMenuCmd                    = 27;                            {itemCmd == 0x001B ==> hierarchical menu}
  45.     hierMenu                    = -1;                            {a hierarchical menu - for InsertMenu call}
  46.     mPopUpMsg                    = 3;                            {menu defProc messages - place yourself}
  47.     mctAllItems                    = -98;                            {search for all Items for the given ID}
  48.     mctLastIDIndic                = -99;                            {last color table entry has this in ID field}
  49.  
  50. {$IFC UNDEFINED STRICT_MENUS }
  51. {$SETC STRICT_MENUS := 0}
  52. {$ENDC}
  53. {$IFC STRICT_MENUS }
  54.     
  55. TYPE
  56.     MenuRef = Ptr;
  57.  
  58.     MenuHandle = MenuRef;
  59.  
  60. {$ELSEC}
  61.  
  62. TYPE
  63.     MenuInfo = RECORD
  64.         menuID:                    INTEGER;
  65.         menuWidth:                INTEGER;
  66.         menuHeight:                INTEGER;
  67.         menuProc:                Handle;
  68.         enableFlags:            LONGINT;
  69.         menuData:                Str255;
  70.     END;
  71.  
  72.     MenuPtr = ^MenuInfo;
  73.     MenuHandle = ^MenuPtr;
  74.  
  75.     MenuRef = MenuHandle;
  76.  
  77. {$ENDC}
  78.     MenuDefProcPtr = ProcPtr;  { PROCEDURE MenuDef(message: INTEGER; theMenu: MenuRef; VAR menuRect: Rect; hitPt: Point; VAR whichItem: INTEGER); }
  79.     MenuBarDefProcPtr = ProcPtr;  { FUNCTION MenuBarDef(selector: INTEGER; message: INTEGER; parameter1: INTEGER; parameter2: LONGINT): LONGINT; }
  80.     MenuHookProcPtr = ProcPtr;  { PROCEDURE MenuHook; }
  81.     MBarHookProcPtr = ProcPtr;  { FUNCTION MBarHook(VAR menuRect: Rect): INTEGER; }
  82.     MenuDefUPP = UniversalProcPtr;
  83.     MenuBarDefUPP = UniversalProcPtr;
  84.     MenuHookUPP = UniversalProcPtr;
  85.     MBarHookUPP = UniversalProcPtr;
  86.  
  87. CONST
  88.     uppMenuDefProcInfo = $0000FF80; { PROCEDURE (2 byte param, 4 byte param, 4 byte param, 4 byte param, 4 byte param); }
  89.     uppMenuBarDefProcInfo = $00003AB0; { FUNCTION (2 byte param, 2 byte param, 2 byte param, 4 byte param): 4 byte result; }
  90.     uppMenuHookProcInfo = $00000000; { PROCEDURE ; }
  91.     uppMBarHookProcInfo = $000000CF; { SPECIAL_CASE_PROCINFO( kSpecialCaseMBarHook ) }
  92.  
  93. FUNCTION NewMenuDefProc(userRoutine: MenuDefProcPtr): MenuDefUPP;
  94.     {$IFC NOT GENERATINGCFM }
  95.     INLINE $2E9F;
  96.     {$ENDC}
  97.  
  98. FUNCTION NewMenuBarDefProc(userRoutine: MenuBarDefProcPtr): MenuBarDefUPP;
  99.     {$IFC NOT GENERATINGCFM }
  100.     INLINE $2E9F;
  101.     {$ENDC}
  102.  
  103. FUNCTION NewMenuHookProc(userRoutine: MenuHookProcPtr): MenuHookUPP;
  104.     {$IFC NOT GENERATINGCFM }
  105.     INLINE $2E9F;
  106.     {$ENDC}
  107.  
  108. FUNCTION NewMBarHookProc(userRoutine: MBarHookProcPtr): MBarHookUPP;
  109.     {$IFC NOT GENERATINGCFM }
  110.     INLINE $2E9F;
  111.     {$ENDC}
  112.  
  113. PROCEDURE CallMenuDefProc(message: INTEGER; theMenu: MenuRef; VAR menuRect: Rect; hitPt: Point; VAR whichItem: INTEGER; userRoutine: MenuDefUPP);
  114.     {$IFC NOT GENERATINGCFM}
  115.     INLINE $205F, $4E90;
  116.     {$ENDC}
  117.  
  118. FUNCTION CallMenuBarDefProc(selector: INTEGER; message: INTEGER; parameter1: INTEGER; parameter2: LONGINT; userRoutine: MenuBarDefUPP): LONGINT;
  119.     {$IFC NOT GENERATINGCFM}
  120.     INLINE $205F, $4E90;
  121.     {$ENDC}
  122.  
  123. PROCEDURE CallMenuHookProc(userRoutine: MenuHookUPP);
  124.     {$IFC NOT GENERATINGCFM}
  125.     INLINE $205F, $4E90;
  126.     {$ENDC}
  127.  
  128. FUNCTION CallMBarHookProc(VAR menuRect: Rect; userRoutine: MBarHookUPP): INTEGER;
  129.     {$IFC NOT GENERATINGCFM}
  130.     {To be implemented:  Glue to move parameters according to special case conventions.}
  131.     {$ENDC}
  132.  
  133. TYPE
  134.     MCEntry = RECORD
  135.         mctID:                    INTEGER;                                {menu ID.  ID = 0 is the menu bar}
  136.         mctItem:                INTEGER;                                {menu Item. Item = 0 is a title}
  137.         mctRGB1:                RGBColor;                                {usage depends on ID and Item}
  138.         mctRGB2:                RGBColor;                                {usage depends on ID and Item}
  139.         mctRGB3:                RGBColor;                                {usage depends on ID and Item}
  140.         mctRGB4:                RGBColor;                                {usage depends on ID and Item}
  141.         mctReserved:            INTEGER;                                {reserved for internal use}
  142.     END;
  143.  
  144.     MCEntryPtr = ^MCEntry;
  145.  
  146.     MCTable = ARRAY [0..0] OF MCEntry;
  147.  
  148.     MCTablePtr = ^MCTable;
  149.     MCTableHandle = ^MCTablePtr;
  150.  
  151.     MenuCRsrc = RECORD
  152.         numEntries:                INTEGER;                                {number of entries}
  153.         mcEntryRecs:            MCTable;                                {ARRAY [1..0] of MCEntry}
  154.     END;
  155.  
  156.     MenuCRsrcPtr = ^MenuCRsrc;
  157.     MenuCRsrcHandle = ^MenuCRsrcPtr;
  158.  
  159. FUNCTION GetMBarHeight : INTEGER;
  160.     {$IFC NOT CFMSYSTEMCALLS}
  161.     INLINE $3EB8, $0BAA;            { MOVE.w $0BAA,(SP) }
  162.     {$ENDC}
  163.  
  164. PROCEDURE InitMenus;
  165.     {$IFC NOT GENERATINGCFM}
  166.     INLINE $A930;
  167.     {$ENDC}
  168. FUNCTION NewMenu(menuID: INTEGER; menuTitle: ConstStr255Param): MenuRef;
  169.     {$IFC NOT GENERATINGCFM}
  170.     INLINE $A931;
  171.     {$ENDC}
  172. FUNCTION GetMenu(resourceID: INTEGER): MenuRef;
  173.     {$IFC NOT GENERATINGCFM}
  174.     INLINE $A9BF;
  175.     {$ENDC}
  176. PROCEDURE DisposeMenu(theMenu: MenuRef);
  177.     {$IFC NOT GENERATINGCFM}
  178.     INLINE $A932;
  179.     {$ENDC}
  180. PROCEDURE AppendMenu(menu: MenuRef; data: ConstStr255Param);
  181.     {$IFC NOT GENERATINGCFM}
  182.     INLINE $A933;
  183.     {$ENDC}
  184. PROCEDURE AppendResMenu(theMenu: MenuRef; theType: ResType);
  185.     {$IFC NOT GENERATINGCFM}
  186.     INLINE $A94D;
  187.     {$ENDC}
  188. PROCEDURE InsertResMenu(theMenu: MenuRef; theType: ResType; afterItem: INTEGER);
  189.     {$IFC NOT GENERATINGCFM}
  190.     INLINE $A951;
  191.     {$ENDC}
  192. PROCEDURE InsertMenu(theMenu: MenuRef; beforeID: INTEGER);
  193.     {$IFC NOT GENERATINGCFM}
  194.     INLINE $A935;
  195.     {$ENDC}
  196. PROCEDURE DrawMenuBar;
  197.     {$IFC NOT GENERATINGCFM}
  198.     INLINE $A937;
  199.     {$ENDC}
  200. PROCEDURE InvalMenuBar;
  201.     {$IFC NOT GENERATINGCFM}
  202.     INLINE $A81D;
  203.     {$ENDC}
  204. PROCEDURE DeleteMenu(menuID: INTEGER);
  205.     {$IFC NOT GENERATINGCFM}
  206.     INLINE $A936;
  207.     {$ENDC}
  208. PROCEDURE ClearMenuBar;
  209.     {$IFC NOT GENERATINGCFM}
  210.     INLINE $A934;
  211.     {$ENDC}
  212. FUNCTION GetNewMBar(menuBarID: INTEGER): Handle;
  213.     {$IFC NOT GENERATINGCFM}
  214.     INLINE $A9C0;
  215.     {$ENDC}
  216. FUNCTION GetMenuBar: Handle;
  217.     {$IFC NOT GENERATINGCFM}
  218.     INLINE $A93B;
  219.     {$ENDC}
  220. PROCEDURE SetMenuBar(menuList: Handle);
  221.     {$IFC NOT GENERATINGCFM}
  222.     INLINE $A93C;
  223.     {$ENDC}
  224. PROCEDURE InsertMenuItem(theMenu: MenuRef; itemString: ConstStr255Param; afterItem: INTEGER);
  225.     {$IFC NOT GENERATINGCFM}
  226.     INLINE $A826;
  227.     {$ENDC}
  228. PROCEDURE DeleteMenuItem(theMenu: MenuRef; item: INTEGER);
  229.     {$IFC NOT GENERATINGCFM}
  230.     INLINE $A952;
  231.     {$ENDC}
  232. FUNCTION MenuKey(ch: CHAR): LONGINT;
  233.     {$IFC NOT GENERATINGCFM}
  234.     INLINE $A93E;
  235.     {$ENDC}
  236. PROCEDURE HiliteMenu(menuID: INTEGER);
  237.     {$IFC NOT GENERATINGCFM}
  238.     INLINE $A938;
  239.     {$ENDC}
  240. PROCEDURE SetMenuItemText(theMenu: MenuRef; item: INTEGER; itemString: ConstStr255Param);
  241.     {$IFC NOT GENERATINGCFM}
  242.     INLINE $A947;
  243.     {$ENDC}
  244. PROCEDURE GetMenuItemText(theMenu: MenuRef; item: INTEGER; VAR itemString: Str255);
  245.     {$IFC NOT GENERATINGCFM}
  246.     INLINE $A946;
  247.     {$ENDC}
  248. PROCEDURE DisableItem(theMenu: MenuRef; item: INTEGER);
  249.     {$IFC NOT GENERATINGCFM}
  250.     INLINE $A93A;
  251.     {$ENDC}
  252. PROCEDURE EnableItem(theMenu: MenuRef; item: INTEGER);
  253.     {$IFC NOT GENERATINGCFM}
  254.     INLINE $A939;
  255.     {$ENDC}
  256. PROCEDURE CheckItem(theMenu: MenuRef; item: INTEGER; checked: BOOLEAN);
  257.     {$IFC NOT GENERATINGCFM}
  258.     INLINE $A945;
  259.     {$ENDC}
  260. PROCEDURE SetItemMark(theMenu: MenuRef; item: INTEGER; markChar: CHAR);
  261.     {$IFC NOT GENERATINGCFM}
  262.     INLINE $A944;
  263.     {$ENDC}
  264. PROCEDURE GetItemMark(theMenu: MenuRef; item: INTEGER; VAR markChar: CHAR);
  265.     {$IFC NOT GENERATINGCFM}
  266.     INLINE $A943;
  267.     {$ENDC}
  268. PROCEDURE SetItemIcon(theMenu: MenuRef; item: INTEGER; iconIndex: INTEGER);
  269.     {$IFC NOT GENERATINGCFM}
  270.     INLINE $A940;
  271.     {$ENDC}
  272. PROCEDURE GetItemIcon(theMenu: MenuRef; item: INTEGER; VAR iconIndex: Byte);
  273.     {$IFC NOT GENERATINGCFM}
  274.     INLINE $A93F;
  275.     {$ENDC}
  276. PROCEDURE SetItemStyle(theMenu: MenuRef; item: INTEGER; chStyle: Style);
  277.     {$IFC NOT GENERATINGCFM}
  278.     INLINE $A942;
  279.     {$ENDC}
  280. PROCEDURE GetItemStyle(theMenu: MenuRef; item: INTEGER; VAR chStyle: Style);
  281. PROCEDURE CalcMenuSize(theMenu: MenuRef);
  282.     {$IFC NOT GENERATINGCFM}
  283.     INLINE $A948;
  284.     {$ENDC}
  285. FUNCTION CountMItems(theMenu: MenuRef): INTEGER;
  286.     {$IFC NOT GENERATINGCFM}
  287.     INLINE $A950;
  288.     {$ENDC}
  289. FUNCTION GetMenuHandle(menuID: INTEGER): MenuRef;
  290.     {$IFC NOT GENERATINGCFM}
  291.     INLINE $A949;
  292.     {$ENDC}
  293. PROCEDURE FlashMenuBar(menuID: INTEGER);
  294.     {$IFC NOT GENERATINGCFM}
  295.     INLINE $A94C;
  296.     {$ENDC}
  297. PROCEDURE SetMenuFlash(count: INTEGER);
  298.     {$IFC NOT GENERATINGCFM}
  299.     INLINE $A94A;
  300.     {$ENDC}
  301. FUNCTION MenuSelect(startPt: Point): LONGINT;
  302.     {$IFC NOT GENERATINGCFM}
  303.     INLINE $A93D;
  304.     {$ENDC}
  305. PROCEDURE InitProcMenu(resID: INTEGER);
  306.     {$IFC NOT GENERATINGCFM}
  307.     INLINE $A808;
  308.     {$ENDC}
  309. PROCEDURE GetItemCmd(theMenu: MenuRef; item: INTEGER; VAR cmdChar: CHAR);
  310.     {$IFC NOT GENERATINGCFM}
  311.     INLINE $A84E;
  312.     {$ENDC}
  313. PROCEDURE SetItemCmd(theMenu: MenuRef; item: INTEGER; cmdChar: CHAR);
  314.     {$IFC NOT GENERATINGCFM}
  315.     INLINE $A84F;
  316.     {$ENDC}
  317. FUNCTION PopUpMenuSelect(menu: MenuRef; top: INTEGER; left: INTEGER; popUpItem: INTEGER): LONGINT;
  318.     {$IFC NOT GENERATINGCFM}
  319.     INLINE $A80B;
  320.     {$ENDC}
  321. FUNCTION MenuChoice: LONGINT;
  322.     {$IFC NOT GENERATINGCFM}
  323.     INLINE $AA66;
  324.     {$ENDC}
  325. PROCEDURE DeleteMCEntries(menuID: INTEGER; menuItem: INTEGER);
  326.     {$IFC NOT GENERATINGCFM}
  327.     INLINE $AA60;
  328.     {$ENDC}
  329. FUNCTION GetMCInfo: MCTableHandle;
  330.     {$IFC NOT GENERATINGCFM}
  331.     INLINE $AA61;
  332.     {$ENDC}
  333. PROCEDURE SetMCInfo(menuCTbl: MCTableHandle);
  334.     {$IFC NOT GENERATINGCFM}
  335.     INLINE $AA62;
  336.     {$ENDC}
  337. PROCEDURE DisposeMCInfo(menuCTbl: MCTableHandle);
  338.     {$IFC NOT GENERATINGCFM}
  339.     INLINE $AA63;
  340.     {$ENDC}
  341. FUNCTION GetMCEntry(menuID: INTEGER; menuItem: INTEGER): MCEntryPtr;
  342.     {$IFC NOT GENERATINGCFM}
  343.     INLINE $AA64;
  344.     {$ENDC}
  345. PROCEDURE SetMCEntries(numEntries: INTEGER; menuCEntries: MCTablePtr);
  346.     {$IFC NOT GENERATINGCFM}
  347.     INLINE $AA65;
  348.     {$ENDC}
  349. PROCEDURE InsertFontResMenu(theMenu: MenuRef; afterItem: INTEGER; scriptFilter: INTEGER);
  350.     {$IFC NOT GENERATINGCFM}
  351.     INLINE $303C, $0400, $A825;
  352.     {$ENDC}
  353. PROCEDURE InsertIntlResMenu(theMenu: MenuRef; theType: ResType; afterItem: INTEGER; scriptFilter: INTEGER);
  354.     {$IFC NOT GENERATINGCFM}
  355.     INLINE $303C, $0601, $A825;
  356.     {$ENDC}
  357. FUNCTION SystemEdit(editCmd: INTEGER): BOOLEAN;
  358.     {$IFC NOT GENERATINGCFM}
  359.     INLINE $A9C2;
  360.     {$ENDC}
  361. PROCEDURE SystemMenu(menuResult: LONGINT);
  362.     {$IFC NOT GENERATINGCFM}
  363.     INLINE $A9B5;
  364.     {$ENDC}
  365. {$IFC OLDROUTINENAMES }
  366. PROCEDURE AddResMenu(theMenu: MenuRef; theType: ResType);
  367.     {$IFC NOT GENERATINGCFM}
  368.     INLINE $A94D;
  369.     {$ENDC}
  370. PROCEDURE InsMenuItem(theMenu: MenuRef; itemString: ConstStr255Param; afterItem: INTEGER);
  371.     {$IFC NOT GENERATINGCFM}
  372.     INLINE $A826;
  373.     {$ENDC}
  374. PROCEDURE DelMenuItem(theMenu: MenuRef; item: INTEGER);
  375.     {$IFC NOT GENERATINGCFM}
  376.     INLINE $A952;
  377.     {$ENDC}
  378. PROCEDURE SetItem(theMenu: MenuRef; item: INTEGER; itemString: ConstStr255Param);
  379.     {$IFC NOT GENERATINGCFM}
  380.     INLINE $A947;
  381.     {$ENDC}
  382. PROCEDURE GetItem(theMenu: MenuRef; item: INTEGER; VAR itemString: Str255);
  383.     {$IFC NOT GENERATINGCFM}
  384.     INLINE $A946;
  385.     {$ENDC}
  386. FUNCTION GetMHandle(menuID: INTEGER): MenuRef;
  387.     {$IFC NOT GENERATINGCFM}
  388.     INLINE $A949;
  389.     {$ENDC}
  390. PROCEDURE DelMCEntries(menuID: INTEGER; menuItem: INTEGER);
  391.     {$IFC NOT GENERATINGCFM}
  392.     INLINE $AA60;
  393.     {$ENDC}
  394. PROCEDURE DispMCInfo(menuCTbl: MCTableHandle);
  395.     {$IFC NOT GENERATINGCFM}
  396.     INLINE $AA63;
  397.     {$ENDC}
  398. {$ENDC}
  399.  
  400. { $ALIGN RESET}
  401. { $POP}
  402.  
  403. {$ENDC} {__MENUS__}
  404.  
  405.  IMPLEMENTATION
  406.  END.
  407.  
  408.